// Copyright (c) 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "net/log/net_log.h"

#include <utility>

#include "base/bind.h"
#include "base/macros.h"
#include "base/memory/ptr_util.h"
#include "base/synchronization/waitable_event.h"
#include "base/threading/simple_thread.h"
#include "base/values.h"
#include "net/base/net_errors.h"
#include "net/log/test_net_log.h"
#include "net/log/test_net_log_entry.h"
#include "net/log/test_net_log_util.h"

namespace net {

namespace {

    const int kThreads = 10;
    const int kEvents = 100;

    // Under the hood a NetLogCaptureMode is simply an int. But for layering reasons
    // this internal value is not exposed. These tests need to serialize a
    // NetLogCaptureMode to a base::Value, so create our own private mapping.
    int CaptureModeToInt(NetLogCaptureMode capture_mode)
    {
        if (capture_mode == NetLogCaptureMode::Default())
            return 0;
        if (capture_mode == NetLogCaptureMode::IncludeCookiesAndCredentials())
            return 1;
        if (capture_mode == NetLogCaptureMode::IncludeSocketBytes())
            return 2;

        ADD_FAILURE() << "Unknown capture mode";
        return -1;
    }

    std::unique_ptr<base::Value> CaptureModeToValue(
        NetLogCaptureMode capture_mode)
    {
        return base::WrapUnique(
            new base::FundamentalValue(CaptureModeToInt(capture_mode)));
    }

    std::unique_ptr<base::Value> NetCaptureModeCallback(
        NetLogCaptureMode capture_mode)
    {
        std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
        dict->Set("capture_mode", CaptureModeToValue(capture_mode));
        return std::move(dict);
    }

    TEST(NetLogTest, Basic)
    {
        TestNetLog net_log;
        TestNetLogEntry::List entries;
        net_log.GetEntries(&entries);
        EXPECT_EQ(0u, entries.size());

        net_log.AddGlobalEntry(NetLog::TYPE_CANCELLED);

        net_log.GetEntries(&entries);
        ASSERT_EQ(1u, entries.size());
        EXPECT_EQ(NetLog::TYPE_CANCELLED, entries[0].type);
        EXPECT_EQ(NetLog::SOURCE_NONE, entries[0].source.type);
        EXPECT_NE(NetLog::Source::kInvalidId, entries[0].source.id);
        EXPECT_EQ(NetLog::PHASE_NONE, entries[0].phase);
        EXPECT_GE(base::TimeTicks::Now(), entries[0].time);
        EXPECT_FALSE(entries[0].params);
    }

    // Check that the correct CaptureMode is sent to NetLog Value callbacks.
    TEST(NetLogTest, CaptureModes)
    {
        NetLogCaptureMode kModes[] = {
            NetLogCaptureMode::Default(),
            NetLogCaptureMode::IncludeCookiesAndCredentials(),
            NetLogCaptureMode::IncludeSocketBytes(),
        };

        TestNetLog net_log;

        for (NetLogCaptureMode mode : kModes) {
            net_log.SetCaptureMode(mode);
            EXPECT_EQ(mode, net_log.GetObserver()->capture_mode());

            net_log.AddGlobalEntry(NetLog::TYPE_SOCKET_ALIVE,
                base::Bind(NetCaptureModeCallback));

            TestNetLogEntry::List entries;
            net_log.GetEntries(&entries);

            ASSERT_EQ(1u, entries.size());
            EXPECT_EQ(NetLog::TYPE_SOCKET_ALIVE, entries[0].type);
            EXPECT_EQ(NetLog::SOURCE_NONE, entries[0].source.type);
            EXPECT_NE(NetLog::Source::kInvalidId, entries[0].source.id);
            EXPECT_EQ(NetLog::PHASE_NONE, entries[0].phase);
            EXPECT_GE(base::TimeTicks::Now(), entries[0].time);

            int logged_capture_mode;
            ASSERT_TRUE(
                entries[0].GetIntegerValue("capture_mode", &logged_capture_mode));
            EXPECT_EQ(CaptureModeToInt(mode), logged_capture_mode);

            net_log.Clear();
        }
    }

    class CountingObserver : public NetLog::ThreadSafeObserver {
    public:
        CountingObserver()
            : count_(0)
        {
        }

        ~CountingObserver() override
        {
            if (net_log())
                net_log()->DeprecatedRemoveObserver(this);
        }

        void OnAddEntry(const NetLog::Entry& entry) override { ++count_; }

        int count() const { return count_; }

    private:
        int count_;
    };

    class LoggingObserver : public NetLog::ThreadSafeObserver {
    public:
        LoggingObserver() { }

        ~LoggingObserver() override
        {
            if (net_log())
                net_log()->DeprecatedRemoveObserver(this);
        }

        void OnAddEntry(const NetLog::Entry& entry) override
        {
            std::unique_ptr<base::DictionaryValue> dict = base::DictionaryValue::From(entry.ToValue());
            ASSERT_TRUE(dict);
            values_.push_back(std::move(dict));
        }

        size_t GetNumValues() const { return values_.size(); }
        base::DictionaryValue* GetValue(size_t index) const
        {
            return values_[index].get();
        }

    private:
        std::vector<std::unique_ptr<base::DictionaryValue>> values_;
    };

    void AddEvent(NetLog* net_log)
    {
        net_log->AddGlobalEntry(NetLog::TYPE_CANCELLED,
            base::Bind(CaptureModeToValue));
    }

    // A thread that waits until an event has been signalled before calling
    // RunTestThread.
    class NetLogTestThread : public base::SimpleThread {
    public:
        NetLogTestThread()
            : base::SimpleThread("NetLogTest")
            , net_log_(NULL)
            , start_event_(NULL)
        {
        }

        // We'll wait for |start_event| to be triggered before calling a subclass's
        // subclass's RunTestThread() function.
        void Init(NetLog* net_log, base::WaitableEvent* start_event)
        {
            start_event_ = start_event;
            net_log_ = net_log;
        }

        void Run() override
        {
            start_event_->Wait();
            RunTestThread();
        }

        // Subclasses must override this with the code they want to run on their
        // thread.
        virtual void RunTestThread() = 0;

    protected:
        NetLog* net_log_;

    private:
        // Only triggered once all threads have been created, to make it less likely
        // each thread completes before the next one starts.
        base::WaitableEvent* start_event_;

        DISALLOW_COPY_AND_ASSIGN(NetLogTestThread);
    };

    // A thread that adds a bunch of events to the NetLog.
    class AddEventsTestThread : public NetLogTestThread {
    public:
        AddEventsTestThread() { }
        ~AddEventsTestThread() override { }

    private:
        void RunTestThread() override
        {
            for (int i = 0; i < kEvents; ++i)
                AddEvent(net_log_);
        }

        DISALLOW_COPY_AND_ASSIGN(AddEventsTestThread);
    };

    // A thread that adds and removes an observer from the NetLog repeatedly.
    class AddRemoveObserverTestThread : public NetLogTestThread {
    public:
        AddRemoveObserverTestThread() { }

        ~AddRemoveObserverTestThread() override { EXPECT_TRUE(!observer_.net_log()); }

    private:
        void RunTestThread() override
        {
            for (int i = 0; i < kEvents; ++i) {
                ASSERT_FALSE(observer_.net_log());

                net_log_->DeprecatedAddObserver(
                    &observer_, NetLogCaptureMode::IncludeCookiesAndCredentials());
                ASSERT_EQ(net_log_, observer_.net_log());
                ASSERT_EQ(NetLogCaptureMode::IncludeCookiesAndCredentials(),
                    observer_.capture_mode());

                net_log_->SetObserverCaptureMode(&observer_,
                    NetLogCaptureMode::IncludeSocketBytes());
                ASSERT_EQ(net_log_, observer_.net_log());
                ASSERT_EQ(NetLogCaptureMode::IncludeSocketBytes(),
                    observer_.capture_mode());

                net_log_->DeprecatedRemoveObserver(&observer_);
                ASSERT_TRUE(!observer_.net_log());
            }
        }

        CountingObserver observer_;

        DISALLOW_COPY_AND_ASSIGN(AddRemoveObserverTestThread);
    };

    // Creates |kThreads| threads of type |ThreadType| and then runs them all
    // to completion.
    template <class ThreadType>
    void RunTestThreads(NetLog* net_log)
    {
        ThreadType threads[kThreads];
        base::WaitableEvent start_event(
            base::WaitableEvent::ResetPolicy::MANUAL,
            base::WaitableEvent::InitialState::NOT_SIGNALED);

        for (size_t i = 0; i < arraysize(threads); ++i) {
            threads[i].Init(net_log, &start_event);
            threads[i].Start();
        }

        start_event.Signal();

        for (size_t i = 0; i < arraysize(threads); ++i)
            threads[i].Join();
    }

    // Makes sure that events on multiple threads are dispatched to all observers.
    TEST(NetLogTest, NetLogEventThreads)
    {
        NetLog net_log;

        // Attach some observers.  Since they're created after |net_log|, they'll
        // safely detach themselves on destruction.
        CountingObserver observers[3];
        for (size_t i = 0; i < arraysize(observers); ++i) {
            net_log.DeprecatedAddObserver(&observers[i],
                NetLogCaptureMode::IncludeSocketBytes());
        }

        // Run a bunch of threads to completion, each of which will emit events to
        // |net_log|.
        RunTestThreads<AddEventsTestThread>(&net_log);

        // Check that each observer saw the emitted events.
        const int kTotalEvents = kThreads * kEvents;
        for (size_t i = 0; i < arraysize(observers); ++i)
            EXPECT_EQ(kTotalEvents, observers[i].count());
    }

    // Test adding and removing a single observer.
    TEST(NetLogTest, NetLogAddRemoveObserver)
    {
        NetLog net_log;
        CountingObserver observer;

        AddEvent(&net_log);
        EXPECT_EQ(0, observer.count());
        EXPECT_EQ(NULL, observer.net_log());
        EXPECT_FALSE(net_log.IsCapturing());

        // Add the observer and add an event.
        net_log.DeprecatedAddObserver(
            &observer, NetLogCaptureMode::IncludeCookiesAndCredentials());
        EXPECT_TRUE(net_log.IsCapturing());
        EXPECT_EQ(&net_log, observer.net_log());
        EXPECT_EQ(NetLogCaptureMode::IncludeCookiesAndCredentials(),
            observer.capture_mode());
        EXPECT_TRUE(net_log.IsCapturing());

        AddEvent(&net_log);
        EXPECT_EQ(1, observer.count());

        // Change the observer's logging level and add an event.
        net_log.SetObserverCaptureMode(&observer,
            NetLogCaptureMode::IncludeSocketBytes());
        EXPECT_EQ(&net_log, observer.net_log());
        EXPECT_EQ(NetLogCaptureMode::IncludeSocketBytes(), observer.capture_mode());
        EXPECT_TRUE(net_log.IsCapturing());

        AddEvent(&net_log);
        EXPECT_EQ(2, observer.count());

        // Remove observer and add an event.
        net_log.DeprecatedRemoveObserver(&observer);
        EXPECT_EQ(NULL, observer.net_log());
        EXPECT_FALSE(net_log.IsCapturing());

        AddEvent(&net_log);
        EXPECT_EQ(2, observer.count());

        // Add the observer a final time, and add an event.
        net_log.DeprecatedAddObserver(&observer,
            NetLogCaptureMode::IncludeSocketBytes());
        EXPECT_EQ(&net_log, observer.net_log());
        EXPECT_EQ(NetLogCaptureMode::IncludeSocketBytes(), observer.capture_mode());
        EXPECT_TRUE(net_log.IsCapturing());

        AddEvent(&net_log);
        EXPECT_EQ(3, observer.count());
    }

    // Test adding and removing two observers at different log levels.
    TEST(NetLogTest, NetLogTwoObservers)
    {
        NetLog net_log;
        LoggingObserver observer[2];

        // Add first observer.
        net_log.DeprecatedAddObserver(
            &observer[0], NetLogCaptureMode::IncludeCookiesAndCredentials());
        EXPECT_EQ(&net_log, observer[0].net_log());
        EXPECT_EQ(NULL, observer[1].net_log());
        EXPECT_EQ(NetLogCaptureMode::IncludeCookiesAndCredentials(),
            observer[0].capture_mode());
        EXPECT_TRUE(net_log.IsCapturing());

        // Add second observer observer.
        net_log.DeprecatedAddObserver(&observer[1],
            NetLogCaptureMode::IncludeSocketBytes());
        EXPECT_EQ(&net_log, observer[0].net_log());
        EXPECT_EQ(&net_log, observer[1].net_log());
        EXPECT_EQ(NetLogCaptureMode::IncludeCookiesAndCredentials(),
            observer[0].capture_mode());
        EXPECT_EQ(NetLogCaptureMode::IncludeSocketBytes(),
            observer[1].capture_mode());
        EXPECT_TRUE(net_log.IsCapturing());

        // Add event and make sure both observers receive it at their respective log
        // levels.
        int param;
        AddEvent(&net_log);
        ASSERT_EQ(1U, observer[0].GetNumValues());
        ASSERT_TRUE(observer[0].GetValue(0)->GetInteger("params", &param));
        EXPECT_EQ(CaptureModeToInt(observer[0].capture_mode()), param);
        ASSERT_EQ(1U, observer[1].GetNumValues());
        ASSERT_TRUE(observer[1].GetValue(0)->GetInteger("params", &param));
        EXPECT_EQ(CaptureModeToInt(observer[1].capture_mode()), param);

        // Remove second observer.
        net_log.DeprecatedRemoveObserver(&observer[1]);
        EXPECT_EQ(&net_log, observer[0].net_log());
        EXPECT_EQ(NULL, observer[1].net_log());
        EXPECT_EQ(NetLogCaptureMode::IncludeCookiesAndCredentials(),
            observer[0].capture_mode());
        EXPECT_TRUE(net_log.IsCapturing());

        // Add event and make sure only second observer gets it.
        AddEvent(&net_log);
        EXPECT_EQ(2U, observer[0].GetNumValues());
        EXPECT_EQ(1U, observer[1].GetNumValues());

        // Remove first observer.
        net_log.DeprecatedRemoveObserver(&observer[0]);
        EXPECT_EQ(NULL, observer[0].net_log());
        EXPECT_EQ(NULL, observer[1].net_log());
        EXPECT_FALSE(net_log.IsCapturing());

        // Add event and make sure neither observer gets it.
        AddEvent(&net_log);
        EXPECT_EQ(2U, observer[0].GetNumValues());
        EXPECT_EQ(1U, observer[1].GetNumValues());
    }

    // Makes sure that adding and removing observers simultaneously on different
    // threads works.
    TEST(NetLogTest, NetLogAddRemoveObserverThreads)
    {
        NetLog net_log;

        // Run a bunch of threads to completion, each of which will repeatedly add
        // and remove an observer, and set its logging level.
        RunTestThreads<AddRemoveObserverTestThread>(&net_log);
    }

} // namespace

} // namespace net
